home *** CD-ROM | disk | FTP | other *** search
/ Aminet 34 / Aminet 34 (2000)(Schatztruhe)[!][Dec 1999].iso / Aminet / dev / lang / jlint.lha / jlint.h < prev    next >
C/C++ Source or Header  |  1999-05-18  |  20KB  |  856 lines
  1. //-< JLINT.H >-------------------------------------------------------*--------*
  2. // Jlint                      Version 1.09       (c) 1998  GARRET    *     ?  *
  3. // (Java Lint)                                                       *   /\|  *
  4. //                                                                   *  /  \  *
  5. //                          Created:     28-Mar-98    K.A. Knizhnik  * / [] \ *
  6. //                          Last update: 20-Aug-98    K.A. Knizhnik  * GARRET *
  7. //-------------------------------------------------------------------*--------*
  8. // Java verifier 
  9. //-------------------------------------------------------------------*--------*
  10.  
  11. #ifndef __JLINT_H__
  12. #define __JLINT_H__
  13.  
  14. #define VERSION 1.09
  15.  
  16. typedef int      int4;
  17. typedef unsigned nat4;
  18.  
  19. #if defined(_WIN32)
  20. #define INT8_DEFINED 1
  21. typedef __int64 int8;
  22. typedef unsigned __int64 nat8;
  23. #else
  24. #if defined(__osf__ )
  25. #define INT8_DEFINED 1
  26. typedef   signed long int8;
  27. typedef unsigned long nat8;
  28. #else
  29. #if defined(__GNUC__)
  30. #define INT8_DEFINED 1
  31. typedef long long          int8;
  32. typedef unsigned long long nat8;
  33. #endif
  34. #endif
  35. #endif
  36.  
  37. #define bool  int
  38. #define true  1
  39. #define false 0
  40.  
  41. #define nobreak 
  42.  
  43. typedef unsigned char  byte;
  44. typedef unsigned short word;
  45.  
  46. enum vbm_instruction_code { 
  47. #define JAVA_INSN(code, mnem, len) mnem,
  48. #include "jlint.d"
  49. last_insn
  50. };
  51.     
  52. #define   items(array) (sizeof(array)/sizeof*(array))
  53.  
  54. inline int unpack2(byte* s) { 
  55.     return (s[0] << 8) + s[1]; 
  56. }
  57.  
  58. inline int unpack4(byte* s) { 
  59.     return (((((s[0] << 8) + s[1]) << 8) + s[2]) << 8) + s[3];
  60. } 
  61.  
  62. inline int unpack2_le(byte* s) { 
  63.     return (s[1] << 8) + s[0]; 
  64. }
  65.  
  66. inline int unpack4_le(byte* s) { 
  67.     return (((((s[3] << 8) + s[2]) << 8) + s[1]) << 8) + s[0];
  68. } 
  69.  
  70. enum type_tag { 
  71.     tp_bool,
  72.     tp_byte,
  73.     tp_char,
  74.     tp_short,
  75.     tp_int,
  76.     tp_long,
  77.     tp_float,
  78.     tp_double,
  79.     tp_void, 
  80.     tp_self,
  81.     tp_string,
  82.     tp_object
  83. };
  84.  
  85. #define IS_INT_TYPE(tp) (tp <= tp_int)
  86. #define IS_ARRAY_TYPE(tp) ((tp & ~0xFF) != 0)
  87.  
  88. struct int_type_range { 
  89.     int4 min;
  90.     int4 max;
  91. };
  92.  
  93.  
  94. enum message_category { 
  95.     cat_deadlock        = 0x00000001, 
  96.     cat_race_condition  = 0x00000002,
  97.     cat_wait_nosync     = 0x00000004,
  98.     cat_synchronization = 0x0000000F,
  99.  
  100.     cat_super_finalize  = 0x00000010,
  101.     cat_not_overridden  = 0x00000020,
  102.     cat_field_redefined = 0x00000040,
  103.     cat_shadow_local    = 0x00000080,
  104.     cat_inheritance     = 0x000000F0,
  105.  
  106.     cat_zero_operand    = 0x00000100,
  107.     cat_zero_result     = 0x00000200, 
  108.     cat_redundant       = 0x00000400,
  109.     cat_overflow        = 0x00000800, 
  110.     cat_incomp_case     = 0x00001000,
  111.     cat_short_char_cmp  = 0x00002000,
  112.     cat_string_cmp      = 0x00004000,
  113.     cat_weak_cmp        = 0x00008000,
  114.     cat_domain          = 0x00010000,
  115.     cat_null_reference  = 0x00020000,
  116.     cat_truncation      = 0x00040000,
  117.     cat_bounds          = 0x00080000,
  118.     cat_data_flow       = 0x000FFF00,
  119.  
  120.     cat_done            = 0x10000000,
  121.  
  122.     cat_all             = 0xFFFFFFFF
  123. };
  124.  
  125. struct message_descriptor {
  126.     message_category category;
  127.     const char*      format;
  128.     const char*      name;
  129.     bool             position_dependent;
  130.     bool             enabled;
  131. };
  132.  
  133. class message_node {
  134.     static message_node* hash_table[];
  135.   public:
  136.     message_node* next;
  137.     char*         text;
  138.  
  139.     static bool find(char* msg);
  140.     static void add_to_hash(char* msg);
  141.  
  142.     message_node(char* msg) { 
  143.     text = strdup(msg);
  144.     next = NULL;
  145.     }
  146.     ~message_node() { delete[] text; }
  147. };
  148.  
  149.  
  150.  
  151. enum message_code { 
  152. #define MSG(category, code, pos, text) msg_##code,
  153. #include "jlint.msg"
  154. msg_last
  155. };
  156.  
  157. #define MSG_LOCATION_PREFIX "%0s:%1d: " // Emacs style: "file:line_number: "
  158.  
  159. #define MAX_MSG_LENGTH      1024
  160. #define MAX_MSG_PARAMETERS  16
  161.  
  162. struct msg_select_category_option { 
  163.     message_category msg_cat;
  164.     const char*      cat_name;
  165.     const char*      cat_desc;
  166. };
  167.  
  168. extern unsigned string_hash_function(byte* p);
  169.  
  170. class utf_string {
  171.   protected:
  172.     int   len;
  173.     byte* data;
  174.  
  175.   public:
  176.     bool operator == (utf_string const& str) const { 
  177.     return len == str.len && memcmp(data, str.data, len) == 0; 
  178.     }
  179.     bool operator != (utf_string const& str) const { 
  180.     return len != str.len || memcmp(data, str.data, len) != 0; 
  181.     }
  182.     bool operator == (const char* str) const { 
  183.     return strcmp((char*)data, str) == 0; 
  184.     }
  185.     bool operator != (const char* str) const { 
  186.     return strcmp((char*)data, str) != 0; 
  187.     }
  188.     unsigned hash() const { 
  189.     return string_hash_function(data);
  190.     }
  191.     int  first_char() const { return data[0]; }
  192.  
  193.     void operator = (utf_string const& str) { 
  194.     len = str.len;
  195.     data = str.data;
  196.     }
  197.  
  198.     utf_string operator + (const char* suffix) const { 
  199.     utf_string str;
  200.     str.len = len + strlen(suffix);
  201.     str.data = new byte[str.len+1];
  202.     memcpy(str.data, data, len);
  203.     memcpy(str.data+len, suffix, str.len - len);
  204.     str.data[str.len] = 0; // zero terminated string
  205.     return str;
  206.     }
  207.  
  208.     void append(int offs, utf_string const& suffix) { 
  209.     assert(offs <= len);
  210.     len = offs + suffix.len;
  211.     byte* new_data = new byte[len+1];
  212.     memcpy(new_data, data, offs);
  213.     memcpy(new_data+offs, suffix.data, suffix.len);
  214.     new_data[len] = 0; // zero terminated string
  215.     delete[] data;
  216.     data = new_data;
  217.     }
  218.  
  219.     int rindex(byte ch) const { 
  220.     byte* p = (byte*)strrchr((char*)data, ch);
  221.     return p ? p - data : -1;
  222.     }
  223.  
  224.     void set_size(int size) { len = size; }
  225.  
  226.     char* as_asciz() const { return (char*)data; }
  227.  
  228.     utf_string(int length, byte* str) { 
  229.     len = length;
  230.     data = new byte[length+1];
  231.     memcpy(data, str, length);
  232.     data[length] = 0;
  233.     }
  234.     utf_string(const char* str) { 
  235.     len = strlen(str);
  236.     data = (byte*)str;
  237.     }
  238.  
  239.     utf_string(utf_string const& str) { 
  240.     len = str.len;
  241.     data = str.data;
  242.     }
  243.     utf_string() { len = 0; data = NULL; }
  244. };
  245.  
  246.     
  247. class method_desc;
  248. class field_desc;
  249. class class_desc;
  250. class constant;
  251.  
  252. class callee_desc {
  253.   public:
  254.     class_desc*    self_class;
  255.     method_desc*   method;
  256.     callee_desc*   next;
  257.     void*          backtrace;
  258.     int            line;
  259.     int            attr;
  260.     enum { 
  261.     i_self          = 0x01, // invoke method of self class
  262.     i_synchronized  = 0x02, // method os invoked from synchronized(){} body
  263.     i_wait_deadlock = 0x04  // invocation can cause deadlock in wait()
  264.     };
  265.     
  266.  
  267.     void message(int msg_code, ...); 
  268.     
  269.     callee_desc(class_desc* cls, method_desc* mth, callee_desc* chain, 
  270.            int lineno, int call_attr) 
  271.     { 
  272.         self_class = cls;  
  273.     method = mth;
  274.     next = chain;
  275.     line = lineno;
  276.     attr = call_attr;
  277.     backtrace = NULL; 
  278.     }
  279. };
  280.  
  281. class access_desc { 
  282.   public: 
  283.     access_desc*   next;
  284.     class_desc*    self_class;
  285.     field_desc*    field;
  286.     int            line;
  287.     int            attr;
  288.     enum { 
  289.     a_self = 0x01, // access to the component of the same class
  290.     a_new  = 0x02  // field of newly created object is accessed
  291.     };
  292.  
  293.     void message(int msg_code, ...); 
  294.  
  295.     access_desc(field_desc* desc, class_desc* cls, 
  296.         int lineno, access_desc* chain)
  297.     { 
  298.     field = desc;
  299.     next = chain;
  300.     self_class = cls;
  301.     line = lineno;
  302.     attr = 0;
  303.     }    
  304. };
  305.  
  306. class graph_vertex;
  307.  
  308. class graph_edge { 
  309.   public:
  310.     graph_edge*   next;
  311.     callee_desc*  invocation;
  312.     method_desc*  caller;
  313.     graph_vertex* vertex;
  314.     int           mask;
  315.  
  316.     void message(int loop_id);
  317.  
  318.     graph_edge(graph_vertex* node, method_desc* method, callee_desc* call) { 
  319.     invocation = call;
  320.     caller = method;
  321.     vertex = node;
  322.     mask = 0;
  323.     }
  324. };
  325.  
  326. class graph_vertex { 
  327.   public:
  328.     graph_edge*   edges;
  329.     graph_vertex* next;
  330.     class_desc*   cls;
  331.     int           visited;
  332.     int           marker;
  333.     int           n_loops;
  334.     enum { 
  335.     flag_vertex_on_path    = 0x80000000,
  336.     flag_vertex_not_marked = 0x7fffffff
  337.     };
  338.     
  339.  
  340.  
  341.     static int    n_vertexes;
  342.  
  343.     static graph_vertex* graph;
  344.     
  345.     static void verify();
  346.  
  347.     void attach(graph_edge* edge) { 
  348.     edge->next = edges;
  349.     edges = edge;
  350.     }
  351.  
  352.     graph_vertex(class_desc* vertex_class) { 
  353.     cls = vertex_class;
  354.     visited = 0;
  355.     marker = flag_vertex_not_marked;
  356.     next = graph;
  357.     graph = this;
  358.     edges = NULL;
  359.     n_vertexes += 1;
  360.     }
  361. };
  362.  
  363. class var_desc { 
  364.   public:
  365.     utf_string     name;
  366.     int            type;
  367.     int            start_pc;
  368.     
  369.     int4           min;
  370.     int4           max;
  371.     int4           mask;
  372.  
  373.     enum object_var_state {
  374.     vs_unknown  = 0x01, // state of variable is unknown
  375.     vs_not_null = 0x03, // variable was checked for null
  376.     vs_new      = 0x04  // variable points to object created by new
  377.     };
  378. };
  379.  
  380. class component_desc { 
  381.   public:
  382.     utf_string     name;
  383.     class_desc*    cls;
  384.     class_desc*    accessor;
  385.     
  386.     component_desc(utf_string const& component_name, class_desc* component_cls)
  387.     : name(component_name), cls(component_cls), accessor(NULL) {}
  388. };
  389.     
  390.  
  391. class field_desc : public component_desc { 
  392.   public:
  393.     field_desc*    next;
  394.     int            attr;
  395.     enum { 
  396.     f_static     = 0x0008, 
  397.     f_final      = 0x0010,
  398.     f_volatile   = 0x0040, 
  399.     
  400.     f_used       = 0x10000,
  401.         f_serialized = 0x20000 // field is accessed only from methods 
  402.                            // of related classes
  403.  
  404.     };
  405.  
  406.     field_desc(utf_string const& field_name, class_desc* owner, 
  407.            field_desc* chain) 
  408.     : component_desc(field_name, owner)
  409.     {
  410.     next = chain; 
  411.     attr = f_serialized;
  412.     }
  413. };
  414.  
  415. struct vbm_operand { 
  416.     int  type;  // type of expression/variable before it was pushed in stack
  417.     int4 max;   // maximal value of operand
  418.     int4 min;   // minimal value of operand
  419.     int4 mask;  // mask of possible set bits and zero value indicator for 
  420.                 // object types
  421.     int  index; // index of local veriable, which value was loaded in stack
  422. };
  423.  
  424.  
  425. class local_context { 
  426.   public:
  427.     enum context_cmd { 
  428.     cmd_pop_var,    // start of local variable scope
  429.     cmd_push_var,   // end of local variable scope
  430.     cmd_merge_ctx,  // forward jump label
  431.     cmd_reset_ctx,  // backward jump label
  432.     cmd_enter_ctx,  // entry point
  433.     cmd_case_ctx,   // switch case label
  434.     cmd_update_ctx, // backward jump
  435.     cmd_save_ctx    // forward jump
  436.     } cmd;
  437.  
  438.     local_context* next;
  439.  
  440.     virtual vbm_operand* transfer(method_desc* method, vbm_operand* sp, 
  441.                   byte cop, byte& prev_cop) = 0;
  442.  
  443.     local_context(context_cmd ctx_cmd, local_context** chain) { 
  444.     cmd = ctx_cmd;
  445.     while (*chain != NULL && (*chain)->cmd < ctx_cmd) { 
  446.         chain = &(*chain)->next;
  447.     }
  448.     next = *chain;
  449.     *chain = this;
  450.     }
  451. };
  452.  
  453. class ctx_pop_var : public local_context { 
  454.   public:
  455.     int var_index;
  456.  
  457.     ctx_pop_var(local_context** chain, int index) 
  458.     : local_context(cmd_pop_var, chain), var_index(index) {}
  459.  
  460.     virtual vbm_operand* transfer(method_desc* method, vbm_operand* sp, 
  461.                   byte cop, byte& prev_cop);
  462. };
  463.  
  464.  
  465. class ctx_push_var : public local_context { 
  466.   public:
  467.     utf_string* var_name;
  468.     int         var_type;
  469.     int         var_index;
  470.     int         var_start_pc;
  471.     
  472.     ctx_push_var(local_context** chain,
  473.          utf_string* name, int type, int index, int start_pc)
  474.     : local_context(cmd_push_var, chain) {
  475.     var_name = name; 
  476.     var_type = type;
  477.     var_index = index;
  478.     var_start_pc = start_pc;
  479.     }
  480.     
  481.  
  482.     virtual vbm_operand* transfer(method_desc* method, vbm_operand* sp, 
  483.                   byte cop, byte& prev_cop);
  484. };
  485.     
  486.  
  487. class ctx_split : public local_context { 
  488.   public: 
  489.     var_desc*    vars; 
  490.     vbm_operand* stack_pointer;
  491.     vbm_operand  stack_top[2];
  492.     int          switch_var_index;
  493.     int          n_branches;
  494.     
  495.     enum jmp_type { jmp_forward, jmp_backward };
  496.  
  497.     ctx_split(local_context** chain, jmp_type type = jmp_forward) 
  498.     : local_context(type == jmp_forward ? cmd_save_ctx : cmd_update_ctx, chain)
  499.     {
  500.     n_branches = 1;
  501.     }
  502.     
  503.     virtual vbm_operand* transfer(method_desc* method, vbm_operand* sp, 
  504.                   byte cop, byte& prev_cop);
  505. };
  506.     
  507.     
  508. class ctx_merge : public local_context { 
  509.   public:
  510.     ctx_split* come_from;
  511.     int        case_value;
  512.     
  513.     ctx_merge(local_context** chain, ctx_split* come_from_ctx) 
  514.     : local_context(cmd_merge_ctx, chain) 
  515.     { 
  516.     come_from = come_from_ctx;
  517.     }
  518.  
  519.     ctx_merge(local_context** chain, ctx_split* come_from_ctx, int value) 
  520.     : local_context(cmd_case_ctx, chain) 
  521.     {
  522.     come_from = come_from_ctx;
  523.     case_value = value;
  524.     }
  525.   
  526.     virtual vbm_operand* transfer(method_desc* method, vbm_operand* sp, 
  527.                   byte cop, byte& prev_cop);
  528. };
  529.  
  530.  
  531. class ctx_entry_point : public local_context { 
  532.   public:
  533.     ctx_entry_point(local_context** chain)
  534.     : local_context(cmd_enter_ctx, chain) {}
  535.     
  536.     virtual vbm_operand* transfer(method_desc* method, 
  537.                   vbm_operand* sp, byte cop, byte& prev_cop);
  538. };
  539.  
  540. class ctx_reset : public local_context { 
  541.   public:
  542.     int* var_store_count;
  543.     
  544.     ctx_reset(local_context** chain, int* counts, int n_vars) 
  545.     : local_context(cmd_reset_ctx, chain) 
  546.     { 
  547.     var_store_count = new int[n_vars];
  548.     memcpy(var_store_count, counts, n_vars*sizeof(int));
  549.     }
  550.     
  551.     virtual vbm_operand* transfer(method_desc* method, vbm_operand* sp, 
  552.                   byte cop, byte& prev_cop);
  553. };
  554.  
  555. class overridden_method { 
  556.   public:
  557.     overridden_method* next;
  558.     method_desc*       method;
  559.  
  560.     overridden_method(method_desc* mth, overridden_method* chain) { 
  561.     method = mth;
  562.     next = chain;
  563.     }
  564. };
  565.  
  566. class method_desc : public component_desc { 
  567.   public:
  568.     utf_string     desc;
  569.     method_desc*   next;
  570.  
  571.     int attr;
  572.     enum { 
  573.     m_static       = 0x0008,
  574.     m_final        = 0x0010,
  575.     m_synchronized = 0x0020,
  576.     m_native       = 0x0100,
  577.     m_abstract     = 0x0400,
  578.  
  579.     m_wait         = 0x010000, // invoke wait()
  580.     m_serialized   = 0x020000, // method is called only from methods 
  581.                                // of related classes
  582.     m_concurrent   = 0x040000, // Method is either run of Runanble protcol
  583.                                // or synchronized or called from them.
  584.     m_visited      = 0x080000, // Used while recursive traversal of methods
  585.     m_deadlock_free= 0x100000, // Doesn't call any synchronized methods
  586.     m_override     = 0x200000  // Override method of base class
  587.     };
  588.  
  589.     int            n_vars;
  590.     var_desc*      vars;
  591.     int*           var_store_count;
  592.  
  593.     bool           local_variable_table_present;
  594.  
  595.     callee_desc*   callees;
  596.     access_desc*   accessors;
  597.     
  598.     graph_vertex*  vertex;
  599.  
  600.     //
  601.     // Chain of methods from derived classes, overriding this method
  602.     //
  603.     overridden_method* overridden; 
  604.  
  605.     //
  606.     // 1 bit in position 'i' of 'null_parameter_mask' means that NULL is 
  607.     // passed as the value of parameter 'i'
  608.     //
  609.     unsigned       null_parameter_mask; 
  610.     //
  611.     // 1 bit in position 'i' of 'unchecked_use_mask' means that formal
  612.     // parameter 'i' is used without check for NULL
  613.     //
  614.     unsigned       unchecked_use_mask;    
  615.  
  616.     int            code_length;
  617.     byte*          code;
  618.  
  619.     local_context**context;
  620.  
  621.     int            first_line; // line corresponing to first method instruction
  622.     int            wait_line;  // line of last wait() invocation in the method
  623.     word*          line_table;
  624.  
  625.     int  demangle_method_name(char* buf);
  626.  
  627.     void calculate_attributes();
  628.  
  629.     void find_access_dependencies();
  630.  
  631.     void build_concurrent_closure();
  632.     void add_to_concurrent_closure(callee_desc* caller, 
  633.                    int call_attr, int depth);
  634.  
  635.     void build_call_graph();
  636.     bool build_call_graph(method_desc* caller, callee_desc* callee,
  637.               int call_attr);
  638.  
  639.     int  print_call_path_to(callee_desc* target, int loop_id, int path_id, 
  640.                 int call_attr = 0, callee_desc* prev = NULL);
  641.  
  642.     void check_synchronization();
  643.     void check_invocations();
  644.  
  645.     bool is_special_method() { return name.first_char() == '<'; }
  646.  
  647.     int  get_line_number(int pc);
  648.     void message(int msg_code, int pc, ...);
  649.  
  650.     void check_variable_for_null(int pc, vbm_operand* sp); 
  651.     void check_array_index(int pc, vbm_operand* sp); 
  652.  
  653.     void basic_blocks_analysis();
  654.  
  655.     void parse_code(constant** constant_pool);
  656.  
  657.     method_desc(utf_string const& mth_name, utf_string const& mth_desc, 
  658.         class_desc* cls_desc, method_desc* chain) 
  659.     : component_desc(mth_name, cls_desc), desc(mth_desc)
  660.     { 
  661.     callees = NULL;
  662.     accessors = NULL;
  663.     attr = m_serialized;
  664.     next = chain;
  665.     first_line = 0;
  666.     overridden = NULL;
  667.     local_variable_table_present = false;
  668.     null_parameter_mask = unchecked_use_mask = 0;
  669.     }
  670. };
  671.  
  672. class class_desc { 
  673.   public:
  674.     utf_string     name;
  675.     utf_string     source_file;
  676.     class_desc*    next;
  677.     class_desc*    collision_chain; 
  678.  
  679.     method_desc*   methods;
  680.  
  681.     int            attr; 
  682.     enum class_attrs { 
  683.     cl_interface = 0x00200,
  684.  
  685.         cl_system    = 0x10000        
  686.     };
  687.  
  688.     int            n_bases;
  689.     class_desc**   bases;
  690.  
  691.     field_desc*    fields;
  692.  
  693.     graph_vertex*  class_vertex;
  694.     graph_vertex*  metaclass_vertex;
  695.  
  696.     static class_desc* get(utf_string const& str);
  697.  
  698.     method_desc* get_method(utf_string const& mth_name, 
  699.                 utf_string const& mth_desc);
  700.  
  701.     field_desc* get_field(utf_string const& field_name);
  702.  
  703.     static class_desc* hash_table[];
  704.     static int         n_classes;
  705.     static class_desc* chain;
  706.  
  707.     bool isa(const char* cls_name);
  708.     bool isa(class_desc* cls);
  709.     bool implements(const char* interface_name);
  710.     bool in_relationship_with(class_desc* cls);
  711.  
  712.     void verify();
  713.     void calculate_attributes();
  714.     void build_class_info();
  715.     void build_call_graph();
  716.     void build_concurrent_closure();
  717.     void check_inheritance(class_desc* derived);
  718.  
  719.     static void global_analysis();
  720.  
  721.     class_desc(utf_string const& str);
  722. };
  723.  
  724.  
  725. enum const_types { 
  726.     c_none,
  727.     c_utf8,
  728.     c_reserver,
  729.     c_integer,
  730.     c_float,
  731.     c_long,
  732.     c_double, 
  733.     c_class,
  734.     c_string,
  735.     c_field_ref,
  736.     c_method_ref,
  737.     c_interface_method_ref,
  738.     c_name_and_type
  739. };
  740.  
  741. class constant { 
  742.   public:
  743.     byte tag;
  744.     virtual int length() = 0;
  745.     virtual type_tag type() { return tp_object; }
  746.     constant(byte* p) { tag = *p; }
  747. };
  748.  
  749.  
  750. class const_utf8 : public constant, public utf_string { 
  751.   public:
  752.     const_utf8(byte* p) : constant(p), utf_string(unpack2(p+1), p+3) {}
  753.     int length() { return 3 + len; }
  754. };
  755.  
  756. class const_int : public constant {
  757.   public:
  758.     int value;
  759.     const_int(byte* p) : constant(p) {
  760.     value = unpack4(p+1);
  761.     }
  762.     int length() { return 5; }
  763.     type_tag type() { return tp_int; }
  764. };
  765.  
  766. class const_float : public constant {
  767.   public:
  768.     const_float(byte* p) : constant(p) {}
  769.     int length() { return 5; }
  770.     type_tag type() { return tp_float; }
  771. };
  772.  
  773. class const_long : public constant {
  774.   public:
  775.     struct { 
  776.     int4 high;
  777.     int4 low;
  778.     } value;
  779.     const_long(byte* p) : constant(p) {
  780.     value.high = unpack4(p+1);
  781.     value.low  = unpack4(p+5);
  782.     }
  783.     int length() { return 9; }
  784.     type_tag type() { return tp_long; }
  785. };
  786.  
  787. class const_double : public constant {
  788.   public:
  789.     const_double(byte* p) : constant(p) {}
  790.     int length() { return 9; }
  791.     type_tag type() { return tp_double; }
  792. };
  793.  
  794. class const_class : public constant {
  795.    public:   
  796.     int name;
  797.     const_class(byte* p) : constant(p) {
  798.     name = unpack2(p+1);
  799.     }
  800.     int length() { return 3; }
  801. };
  802.  
  803. class const_string : public constant {
  804.    public:   
  805.     int str;
  806.     const_string(byte* p) : constant(p) {
  807.     str = unpack2(p+1);
  808.     }
  809.     int length() { return 3; }
  810.     type_tag type() { return tp_string; }
  811. };
  812.  
  813. class const_ref : public constant {
  814.    public:   
  815.     int cls;
  816.     int name_and_type;
  817.     const_ref(byte* p) : constant(p) {
  818.     cls = unpack2(p+1);
  819.     name_and_type = unpack2(p+3);
  820.     }
  821.     int length() { return 5; }
  822. };
  823.  
  824.  
  825. class const_name_and_type : public constant {
  826.    public:   
  827.     int name;
  828.     int desc;
  829.     const_name_and_type(byte* p) : constant(p) {
  830.     name = unpack2(p+1);
  831.     desc = unpack2(p+3);
  832.     }
  833.     int length() { return 5; }
  834. };
  835.  
  836. //
  837. // Constants for extracting zip file
  838. //
  839.  
  840. #define LOCAL_HDR_SIG     "\113\003\004"   /*  bytes, sans "P" (so unzip */
  841. #define LREC_SIZE     26    /* lengths of local file headers, central */
  842. #define CREC_SIZE     42    /*  directory headers, and the end-of-    */
  843. #define ECREC_SIZE    18    /*  central-dir record, respectively      */
  844. #define TOTAL_ENTRIES_CENTRAL_DIR  10
  845. #define SIZE_CENTRAL_DIRECTORY     12
  846. #define C_UNCOMPRESSED_SIZE        20
  847. #define C_FILENAME_LENGTH          24
  848. #define C_EXTRA_FIELD_LENGTH       26
  849. #define C_RELATIVE_OFFSET_LOCAL_HEADER    38
  850. #define L_FILENAME_LENGTH                 22
  851. #define L_EXTRA_FIELD_LENGTH              24
  852.  
  853. #endif
  854.  
  855.  
  856.